/*
 * 分贝传感器
 * 命令示例：
{
  "method": "get",
  "obj": ["DB"]
}
{
  "method": "set",
  "periodic_time": 1000
}
*/
#include "Arduino.h"    
#include <OneButton.h>       
#include <WiFi.h>
#include <SDDC_SDK_lib.h>
#include <cJSON.h>
#include <Wire.h>

 /*
  * 通用宏
  */
#define SDDC_CFG_PORT         680U                 // SDDC 协议使用的端口号
#define PIN_INPUT 0                                // 选择 IO0 进行控制
#define ESP_TASK_STACK_SIZE   4096
#define ESP_TASK_PRIO         25


 /*
  * 传感器宏
  */
#define  Len_db      20
#define  Min_Len_db  5
#define  Max_Len_db  5
#define  Len         100
#define  Max_Len     70

static const int sensor_D_in = 14;                 // 数字量输入引脚
static const int sensor_A_in = A0;                 // 模拟量输入引脚


static const char* ssid     = "EOS-000045";        // WiFi 名
static const char* password = "1234567890";        // WiFi 密码


static  int xTicksToDelay = 100;                   // 周期延时时间
  
OneButton button(PIN_INPUT, true);


 /*
  * 获取AD量函数
  */
unsigned int Get_ad_value(void)
{
    unsigned int AD_TAB[Len];
    unsigned char a,b,c;
    unsigned int temp;
    unsigned long int mindat=0,maxdat=0,sumdat=0;
  
    for(a=0;a<Len;a++)
    {
        AD_TAB[a] = analogRead(sensor_A_in);
        sumdat = sumdat + AD_TAB[a];
    }

    for(b=0;b<Len;b++)    //按从小到大排列
    {
        for(c=0;c<Len-b;c++)
        {
            if(AD_TAB[c] > AD_TAB[c+1])
            {
                temp = AD_TAB[c+1];
                AD_TAB[c+1] = AD_TAB[c];
                AD_TAB[c] = temp;
            }
        }
    }
  
    for(a=(unsigned int)(Len-Max_Len);a<Len;a++)    //删除最大的数据
    {
        maxdat = maxdat + AD_TAB[a];
    }
  
  temp = ((unsigned int)(sumdat - maxdat)/(unsigned int)(Len-Max_Len));    //求平均值
  return  temp;
}

 /*
  * 解析DB数值函数
  */
unsigned int Get_db_value(void)
{
    unsigned int DB_TAB[Len_db];
    unsigned char a,b,c;
    unsigned int temp;
    unsigned long int mindat=0,maxdat=0,sumdat=0;

    for(a=0;a<Len_db;a++)         
    {
        DB_TAB[a] = Get_ad_value();
        sumdat = sumdat + DB_TAB[a];
    }

    for(b=0;b<Len_db;b++)            //按从小到大排列
    {
        for(c=0;c<Len_db-b;c++)
        {
            if(DB_TAB[c] > DB_TAB[c+1])
            {
                temp = DB_TAB[c+1];
                DB_TAB[c+1] = DB_TAB[c];
                DB_TAB[c] = temp;
            }
        }
    }
    for(a=0;a<Min_Len_db;a++)    //删除最小的数据
    {
        mindat = mindat + DB_TAB[a];
    }
    
    for(a=(unsigned int)(Len_db-Max_Len_db);a<Len_db;a++)    //删除最大的数据
    {
        maxdat = maxdat + DB_TAB[a];
    }
    
    temp = ((unsigned int)(sumdat - mindat - maxdat)/(unsigned int)(Len_db - Min_Len_db - Max_Len_db));   //求平均值
    return  temp;
}
 /*
  * 检测状态函数
  */
static void periodic_sensor_task(void *arg)
{
    int newval = 0;
    int oldval = 0;

    // 监控锁开启和关闭状态
    while(1)
    {
        newval = digitalRead(sensor_D_in);
            
        if(newval != oldval)
        {
            if(newval == 1)
            {
                get_sensor();
            }
            if(newval == 0)
            {
                get_sensor();
            }
        } 
        oldval = newval;
        // 任务创建之后，设定延时周期
        delay(xTicksToDelay);
     }
}

/* 
 *  主动数据上报函数
 */
static void get_sensor()
{  
    int sensorValue = 0;
    cJSON *value;
    cJSON *root;
    char  *msg;
     
    value =  cJSON_CreateArray();
    root = cJSON_CreateObject();
    sddc_return_if_fail(value);
    sddc_return_if_fail(root);
      
    sddc_return_if_fail(value);
      
    // 获取传感器数据
    cJSON_AddItemToArray(value, cJSON_CreateString("DB"));            // 这里的字符串要和系统对象状态获取注册结构体里的对应
    cJSON_AddItemToArray(value, cJSON_CreateString("room_status"));   
    cJSON_AddItemToObject(root, "obj", value);
      
    // 发送数据给 EdgerOS
    msg = cJSON_Print(root);
    sddc_printf("主动上报: %s\n",msg);
    object_report(root);
      
    cJSON_Delete(value);
    cJSON_free(msg);
}

/* 
 *  设置周期等待时间
 */
sddc_bool_t periodic_time_set(const uint64_t value)
{
    sddc_printf("修改上报周期\n");
    xTicksToDelay = value;
    return SDDC_TRUE;
}
/* 
 *  单次获取IO数据
 */
sddc_bool_t single_IO_get_sensor(char *objvalue, int value_len)
{
    if(digitalRead(sensor_D_in))
    {
        strncpy(objvalue, "ON", value_len);
    }else
    {
        strncpy(objvalue, "OFF", value_len);
    }
    return SDDC_TRUE;
}

/* 
 *  单次获取数字数据
 */
sddc_bool_t single_NUM_get_sensor(char *objvalue, int value_len)
{
    if(digitalRead(sensor_D_in))
    {
        int value;
        value = Get_db_value();
        snprintf(objvalue, value_len, "%d", value);
    }else
    {
        int value;
        value = Get_db_value();
        snprintf(objvalue, value_len, "%d", value);
    }
    return SDDC_TRUE;
}
/* 
 *  数字量设备对象函数与处理方法注册
 */
NUM_DEV_REGINFO num_dev[] = {
        {"periodic_time",periodic_time_set},
};

/*
 *  显示设备对象函数与处理方法注册
 */
DIS_DEV_REGINFO dis_dev[] = {
};

/*
 * IO设备对象设置函数与处理方法注册
 */
IO_DEV_REGINFO io_dev[] = {
};

/*
 *  系统对象状态获取注册
 */
DEV_STATE_GET  dev_state_get_reg[] = {
        {"room_status",   DEV_IO_TYPE,  single_IO_get_sensor},
        {"DB",   DEV_NUM_TYPE,  single_NUM_get_sensor},
};

/*
 *  当前设备的信息定义
 */
DEV_INFO    dev_info = {
            .name     = "分贝传感器",
            .type     = "device.db",
            .excl     = SDDC_FALSE,
            .desc     = "ESP-32S",
            .model    = "IDDB01B",
            .vendor   = "inspiration-desktop",
};

/*
 *   系统注册对象汇聚
 */
SDDC_CONFIG_INFO sys_cfg = {
        .token             = "1234567890",            // 设备密码
        .devinfo           = &dev_info,               
        .io_dev_reg        = io_dev,
        .io_dev_reg_num    = ARRAY_SIZE(io_dev),
        .num_dev_reg       = num_dev,
        .num_dev_reg_num   = ARRAY_SIZE(num_dev),
        .state_get_reg     = dev_state_get_reg,
        .state_get_reg_num = ARRAY_SIZE(dev_state_get_reg),
        .dis_dev_reg       = dis_dev,
        .dis_dev_num       = ARRAY_SIZE(dis_dev),
};


/*
 * IO0 按键检测任务
 */
static void esp_io0_key_task()
{
    WiFi.disconnect();
    while (WiFi.status() != WL_CONNECTED)
    {
        delay(1000);
        Serial.println("WIFI Wait for Smartconfig");
      
        // 设置为Station模式
        WiFi.mode(WIFI_STA);
      
        // 开始智能配网
        WiFi.beginSmartConfig();
        while (1)
        {
            delay(500);
            // 检查智能配网
            if (WiFi.smartConfigDone())
            {
            // 设置自动连接
            WiFi.setAutoConnect(true);  
            break;
            }
        }
    }
}
/*
 * 循环扫描按键
 */
static void esp_tick_task(void *arg)
{
    void *sddc = arg;
    (void)sddc;
    while(1)
    {
        button.tick();
        delay(100);
    }
}

/*
 * 初始化传感器
 */
void sensor_init()
{
    // 创建传感器任务，周期性检测传感器的数据并发送给 EdgerOS
    xTaskCreate(periodic_sensor_task, "periodic_sensor_task", ESP_TASK_STACK_SIZE, NULL, ESP_TASK_PRIO, NULL);
    // 初始化 GOIP 口为输入模式，接收传感器发送的信息 
    pinMode(sensor_D_in, INPUT);
    pinMode(sensor_A_in, INPUT);

    //第一次通电后延时，目的为给一定时间模块初始化
    delay(2000);          
}

void setup() {
    byte mac[6];
    Serial.begin(115200);
    Serial.setDebugOutput(true);
    Serial.println();

    // 初始化传感器
    sensor_init();

    // 清除一下按键状态机的状态
    button.reset();
  
    // 创建按键扫描线程，长按 IO0 按键，松开后ESP32 将会进入 SmartConfig 模式
    sddc_printf("长按按键进入 Smartconfig...\n");
    button.attachLongPressStop(esp_io0_key_task);
    xTaskCreate(esp_tick_task, "button_tick", ESP_TASK_STACK_SIZE, NULL, ESP_TASK_PRIO, NULL);
    
    // 启动 WiFi 并且连接网络
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) 
    {
        delay(500);
        Serial.print(".");
    }
  
    // 获取并打印 IP 地址
    Serial.println("");
    Serial.println("WiFi connected");
    Serial.print("'ip :");
    Serial.print(WiFi.localIP());
    Serial.println("' to connect"); 
    
    // sddc协议初始化
    sddc_lib_main(&sys_cfg);

    // 获取并打印网卡 mac 地址
    WiFi.macAddress(mac);
    sddc_printf("MAC addr: %02x:%02x:%02x:%02x:%02x:%02x\n",
              mac[5], mac[4], mac[3], mac[2], mac[1], mac[0]);
              
    // 使用网卡 mac 地址设置设备唯一标识 UID
    sddc_set_uid(G_sddc, mac);
}

void loop() {
    // 运行 SDDC 协议循环
    while (1) 
    {
        sddc_printf("SDDC running...\n");
        sddc_run(G_sddc);
        sddc_printf("SDDC quit!\n");
    }

    // 销毁 SDDC 协议
    sddc_destroy(G_sddc);
}
